package jsonCtx

import (
	"encoding/json"
	"strconv"
)
// Json封装对象
type JsonObject struct {
	JsonStr string
	mapData map[string]interface{}
}

// 创建Json对象
func NewJsonObj(jsonStr string) (*JsonObject, error) {
	var mapData map[string]interface{}
	err := json.Unmarshal([]byte(jsonStr), &mapData)
	if nil != err {
		return nil, err
	}
	return new(JsonObject).Init(jsonStr, mapData), nil
}

func NewJsonObj2(mapData map[string]interface{}) *JsonObject {
	return new(JsonObject).Init("", mapData)
}

// 初始化 Json 对象
func (this *JsonObject) Init(jsonStr string, mapData map[string]interface{}) *JsonObject {
	this.JsonStr = jsonStr
	this.mapData = mapData
	return this
}

// 通过key在Json对象重获取interface{}不确定类型数据
func (this *JsonObject) Get(key string, def interface{}) interface{} {
	val, ok := this.mapData[key]
	if ok {
		return val
	}
	return def
}

// 通过key在Json对象中获取整型
func (this *JsonObject) GetInt(key string, def int) int {
	val, ok := this.mapData[key].(int)
	if ok {
		return val
	}
	val2, ok2 := this.mapData[key].(float64)
	if ok2 {
		return int(val2)
	}
	val3, ok3 := this.mapData[key].(float32)
	if ok3 {
		return int(val3)
	}
	return def
}

// 通过key在Json对象中获取浮点型
func (this *JsonObject) GetFloat64(key string, def float64) float64 {
	val, ok := this.mapData[key].(float64)
	if ok {
		return val
	}
	return def
}

// 通过key在Json对象中获取字符串
func (this *JsonObject) GetString(key string, def string) string {
	val, ok := this.mapData[key].(string)
	if ok {
		return val
	}
	return def
}

// 通过key在Json对象中获取 map[int]int
func (this *JsonObject) GetMapInt(key string, def map[int]int) map[int]int {
	val, ok := this.mapData[key].(map[string]interface{})
	if ok {
		ret := map[int]int{}
		for k, v := range val {
			iv, _ := strconv.Atoi(k)
			ret[iv] = int(v.(float64))
		}
		this.mapData[key] = ret
		return ret
	}
	return def
}

// 通过key在Json对象中获取整型切片 []int
func (this *JsonObject) GetListInt(key string, def []int) []int {
	val, ok := this.mapData[key].([]interface{})
	if ok {
		ret := []int{}
		for _, v := range val {
			iv, _ := strconv.Atoi(v.(string))
			ret = append(ret, iv)
		}
		return ret
	}
	return def
}

// 通过key在Json对象中获取接口切片 []interface{}
func (this *JsonObject) GetListInterface(key string, def []interface{}) []interface{} {
	val, ok := this.mapData[key].([]interface{})
	if ok {
		return val
	}
	return def
}

// ......
// todo：如果还需要支持返回其他类型，可在这个文件自定义相关成员函数
